home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Programming / AmigaSDL / amisrc / SDL_mutex.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-16  |  5.4 KB  |  164 lines
  1. /*
  2.     SDL - Simple DirectMedia Layer
  3.     Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
  4.  
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  9.  
  10.     This library is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.     Library General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU Library General Public
  16.     License along with this library; if not, write to the Free
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  
  19.     Sam Lantinga
  20.     slouken@devolution.com
  21. */
  22.  
  23. #ifdef SAVE_RCSID
  24. static char rcsid =
  25.  "@(#) $Id: SDL_mutex.h,v 1.5.2.8 2001/02/17 01:45:30 hercules Exp $";
  26. #endif
  27.  
  28. #ifndef _SDL_mutex_h
  29. #define _SDL_mutex_h
  30.  
  31. /* Functions to provide thread synchronization primitives
  32.  
  33.     These are independent of the other SDL routines.
  34. */
  35.  
  36. #include "SDL_main.h"
  37. #include "SDL_types.h"
  38.  
  39. #include "begin_code.h"
  40. /* Set up for C function definitions, even when using C++ */
  41. #ifdef __cplusplus
  42. extern "C" {
  43. #endif
  44.  
  45. /* Synchronization functions which can time out return this value
  46.    if they time out.
  47. */
  48. #define SDL_MUTEX_TIMEDOUT    1
  49.  
  50. /* This is the timeout value which corresponds to never time out */
  51. #define SDL_MUTEX_MAXWAIT    (~(Uint32)0)
  52.  
  53.  
  54. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  55. /* Mutex functions                                               */
  56. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  57.  
  58. /* The SDL mutex structure, defined in SDL_mutex.c */
  59. struct SDL_mutex;
  60. typedef struct SDL_mutex SDL_mutex;
  61.  
  62. /* Create a mutex, initialized unlocked */
  63. extern DECLSPEC SDL_mutex * SDL_CreateMutex(void);
  64.  
  65. /* Lock the mutex  (Returns 0, or -1 on error) */
  66. #define SDL_LockMutex(m)    SDL_mutexP(m)
  67. extern DECLSPEC int SDL_mutexP(SDL_mutex *mutex);
  68.  
  69. /* Unlock the mutex  (Returns 0, or -1 on error) */
  70. #define SDL_UnlockMutex(m)    SDL_mutexV(m)
  71. extern DECLSPEC int SDL_mutexV(SDL_mutex *mutex);
  72.  
  73. /* Destroy a mutex */
  74. extern DECLSPEC void SDL_DestroyMutex(SDL_mutex *mutex);
  75.  
  76.  
  77. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  78. /* Semaphore functions                                           */
  79. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  80.  
  81. /* The SDL semaphore structure, defined in SDL_sem.c */
  82. struct SDL_semaphore;
  83. typedef struct SDL_semaphore SDL_sem;
  84.  
  85. /* Create a semaphore, initialized with value, returns NULL on failure. */
  86. extern DECLSPEC SDL_sem * SDL_CreateSemaphore(Uint32 initial_value);
  87.  
  88. /* Destroy a semaphore */
  89. extern DECLSPEC void SDL_DestroySemaphore(SDL_sem *sem);
  90.  
  91. /* This function suspends the calling thread until the semaphore pointed 
  92.  * to by sem has a positive count. It then atomically decreases the semaphore
  93.  * count.
  94.  */
  95. extern DECLSPEC int SDL_SemWait(SDL_sem *sem);
  96.  
  97. /* Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds,
  98.    SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error.
  99. */
  100. extern DECLSPEC int SDL_SemTryWait(SDL_sem *sem);
  101.  
  102. /* Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if
  103.    the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in
  104.    the allotted time, and -1 on error.
  105.    On some platforms this function is implemented by looping with a delay
  106.    of 1 ms, and so should be avoided if possible.
  107. */
  108. extern DECLSPEC int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 ms);
  109.  
  110. /* Atomically increases the semaphore's count (not blocking), returns 0,
  111.    or -1 on error.
  112.  */
  113. extern DECLSPEC int SDL_SemPost(SDL_sem *sem);
  114.  
  115. /* Returns the current count of the semaphore */
  116. extern DECLSPEC Uint32 SDL_SemValue(SDL_sem *sem);
  117.  
  118.  
  119. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  120. /* Condition variable functions                                  */
  121. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  122.  
  123. /* The SDL condition variable structure, defined in SDL_cond.c */
  124. struct SDL_cond;
  125. typedef struct SDL_cond SDL_cond;
  126.  
  127. /* Create a condition variable */
  128. extern DECLSPEC SDL_cond * SDL_CreateCond(void);
  129.  
  130. /* Destroy a condition variable */
  131. extern DECLSPEC void SDL_DestroyCond(SDL_cond *cond);
  132.  
  133. /* Restart one of the threads that are waiting on the condition variable,
  134.    returns 0 or -1 on error.
  135.  */
  136. extern DECLSPEC int SDL_CondSignal(SDL_cond *cond);
  137.  
  138. /* Restart all threads that are waiting on the condition variable,
  139.    returns 0 or -1 on error.
  140.  */
  141. extern DECLSPEC int SDL_CondBroadcast(SDL_cond *cond);
  142.  
  143. /* Wait on the condition variable, unlocking the provided mutex.
  144.    The mutex must be locked before entering this function!
  145.    Returns 0 when it is signaled, or -1 on error.
  146.  */
  147. extern DECLSPEC int SDL_CondWait(SDL_cond *cond, SDL_mutex *mut);
  148.  
  149. /* Waits for at most 'ms' milliseconds, and returns 0 if the condition
  150.    variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not
  151.    signaled in the allotted time, and -1 on error.
  152.    On some platforms this function is implemented by looping with a delay
  153.    of 1 ms, and so should be avoided if possible.
  154. */
  155. extern DECLSPEC int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms);
  156.  
  157. /* Ends C function definitions when using C++ */
  158. #ifdef __cplusplus
  159. }
  160. #endif
  161. #include "close_code.h"
  162.  
  163. #endif /* _SDL_mutex_h */
  164.